## 差无此人
'''names = ['张三', '李四', '王五']

a = input('请输入你要查找的姓名')
# print(a)

for i in names:
    if i == a:
        print('找到了')
        break
else:
    print('没找到')'''
import random

'''str = 'Hello word!'
for i in range(0, len(str)):
    print(i, str[i], end='  ')
print('\n', '-------------------')

for i in range(-11, 0):
    print(i, str[i], end='  ')
print('---------------------')'''

'''str = 'Helloworld!'
# 切片操作
print(str[0:5:2])  # 从0开始-5结束(不包含5),步长为2
print(str[0:5:1])  # 起始位置默认为0,步长默认为1 可简写为:str[:5:]
print(str[0::1])  # 省略结束位置默认到字符串结尾
print(str[5::])  # 从5开始-结尾,默认步长
print(str[::2])  # 从开始-结尾,步长为2
# 步长为负数
print(str[::-1])  # 使字符串倒序输出
print(str[-1:-12:1])'''

'''# 序列相加操作
s1 = 'Hello'
s2 = 'Word'
print(s1 + s2)

# 序列的相乘操作
print(s1 * 5)
print('-' * 50)'''

'''str = 'HelloWord'

# in的使用
print('e是否出现在str中:', 'e' in str)
print('b是否出现在str中:', 'b' in str)

# not in
print('e是否不出现在str中:', 'e' not in str)
print('b是否不出现在str中:', 'b' not in str)

# 内置函数的使用
print('len()', len(str))
print('max()', max(str))
print('min()', min(str))

# 序列对象的方法
print('str.index()', str.index('o'))  # o在str中第一次出现的索引位置
print('str.rindex()', str.rindex('o'))  # 下一个出现的位置
# print('str.index()', str.index('a'))  # ValueError: substring not found ,报错的原因是a在str中不存在
print('str.count', str.count('o'))  # 统计o出现的次数'''
'''
## 列表的删除与创建
lst = ['Hello', 'Word', 200, 20, 2]
print(lst)

# 可以使用内置的函数list()创建列表
lst1 = list('Hello')
lst2 = list(range(0, 10, 2))  # 从0开始-10结束不包含10,步长为2
print(lst1)
print(lst2)

# 列表是序列中的一种 对序列的操作符，运算符，函数均可以使用
print(lst + lst1 + lst2)
print(lst1 * 3)
print(len(lst1))
print(max(lst2))
print(min(lst2))
print(lst1.count('o'))
print(lst1.index('o'))

lst4 = [10, 20, 30]
print(lst4)
del lst4
print(lst4)
'''
'''
## 列表的遍历操作

# 使用for循环遍历列表元素
lst5 = ['Tom', 10, 20, 30]
for item in lst5:
    print(item)

# 使用for循环,range()函数,len()函数
for i in range(0, len(lst5)):
    print(i, '--->', lst5[i])

# 第三种遍历方式,使用enumearte()函数
for index, item in enumerate(lst5, start=1):  # 将索引改为序号 可以手动设置序号的起始值
    print(index, '--->', item)
'''

'''
# 列表的相关操作方法
lst = ['Tom', 10, 20, 30]
print('原列表:', lst, '列表内存地址:', id(lst))

# 添加列表的操作
lst.append(40)
print('添加元素后的列表:', lst, '列表内存地址:', id(lst))

# 使用insert(index,x)在指定的index位置上插入元素x
lst.insert(1, 0)
print(lst)

# 列表元素的删除操作
lst.remove('Tom')
print(lst)

# 使用pop(index)根据索引取出元素,然后删除
print(lst.pop(1))
print(lst)

# 清除列表的所有元素
# lst.clear()
# print(lst, id(lst))  # id不会改变

# 列表的逆向输出
lst.reverse()
print(lst)

# 列表的拷贝,将产生一个新的列表 新列表与旧列表元素相同 内存地址不同
new_lst = lst.copy()
print(lst, id(lst))
print(new_lst, id(new_lst))

# 列表元素的修改操作
lst[1] = 'python'
print(lst)
'''

'''
# 列表的排序操作
lst = [4, 5, 1, 7, 3, 8, 10, 16, 2]
print('原列表:', lst)

# 排序,默认升序
lst.sort()  # 排序时在原列表的基础上进行的,不会产生新的列表
print('升序后:', lst)

lst.sort(reverse=True)  # 降序
print('降序后:', lst)
print('-' * 50)

lst2 = ['banana', 'apple', 'Orange', 'pear', 'Grape']
print('原列表:', lst2)
# 升序,先排大写,再排小写
lst2.sort()
print('升序后:', lst2)
# 降序,先排小写,再排大写
lst2.sort(reverse=True)
print('降序后:', lst2)

# 自己指定排序规则,忽略大小写比较
lst2.sort(key=str.lower)  # 都转成小写再排序
print(lst2)
'''

'''
# sorted()函数排序  默认为升序  它将产生新的对象
lst = [4, 5, 1, 7, 3, 8, 10, 16, 2]
print('原列表:', lst)
new_lst = sorted(lst)
print('升序后:', new_lst)

# 降序
tow_lst = sorted(lst, reverse=True)
print('降序后:', tow_lst)

# 忽略大小写进行排序
str_lst = ['Banana', 'apple', 'Orange', 'cherry', 'Pear', 'grape']
sorted_lst = sorted(str_lst, key=str.lower)
print('升序后', sorted_lst)
'''

'''
# 列表生成式
import random

lst = [item for item in range(1, 11)]
print(lst)
lst = [item * item for item in range(1, 11)]
print(lst)

lst = [random.randint(1, 100) for _ in range(1, 11)]
print(lst)

# 从列表中选择符合条件的元素组成新的列表
lst = [item for item in range(1, 11) if item % 2 == 0]
print(lst)
'''

'''
# 二位列表的遍历与生成式
lst = [['城市', '环比', '同比'],
       ['北京', '102', '103'],
       ['上海', '97', '96'],
       ['深圳', '100', '89']]
print(lst)

# 遍历二维列表使用双层for循环
for row in lst:  # 行
    for item in row:  # 列
        print(item, end='\t')
    print()

# 列表生成式  生成一个4行5列的二维列表
lst2 = [[j for j in range(5)] for i in range(4)]
print(lst2)
'''

'''
# 元组的创建与删除
t = ('hello', [10, 20, 30], 'python', 'word')
print(t)

# 使用内置函数tuple()创建元组
t = tuple('helloword')
print(t)

# in   not in
t = tuple([10, 20, 10, 30])
print(t)
print('10在元组中存在:', 10 in t)
print('10在元组中不存在:', 10 not in t)
print('元组中从最大值为:', max(t))
print('元组中的最小值为:', min(t))
print('元组个数:', len(t))
print('20在元组中第一次出现的位置:', t.index(20))
print('10在元组中出现了几次:', t.count(10))

# 如果元组中只有一个元素时,不能省略
t = (10)
print(type(t))
t = (10,)
print(type(t))
# 删除元组
del t
# print(t)'''

'''
# 元组的遍历
t = ('hello', [10, 20, 30], 'python', 'word')
print(t[0:3:2])  # 元组支持切片

# 元组的遍历
for item in t:
    print(item)

# for+range()+len()
for i in range(0, len(t)):  # 可以省略0
    print(i, t[i])

# 使用enumerate() # 传入start可以指定起始索引值
for index, item in enumerate(t, start=1):
    print(index, item)
'''
'''
# 元组生成式
# t= (添加到元组中的元素是谁   for 元素  in  range()   )
t = (i for i in range(1, 4))
print(t)  # 查看到生成器

# t = tuple(t)
# print(t)

# __next__()
print(t.__next__())
print(t.__next__())
print(t.__next__())'''

'''
# 创建字典
d = {0: 'dog', 1: 'cat', 2: 'Tom', 0: 40}
print(d)  # key相同时,value进行了覆盖

# zip() 函数
lst1 = [1, 2, 3, 4]
lst2 = ['tom', 'jerry', 'cat', 'dog', 'pet']
zipobj = zip(lst1, lst2)
print(zipobj)  # 得到一个映射对象
# print(list(zipobj))  # 将映射对象转化为List对象
print(dict(zipobj))

# 使用参数创建字典
d = dict(cat=10, dog=20, pet=30)
print(d)

# 元组可以作为key
t = (10, 20, 30)
print({t: 10})

# 列表不能作为key 因为列表时可变数据类型
# lst = [10, 20, 30]
# print({lst: 10})

# 字典属于序列
print(d)
print('max:', max(d))
print('min:', min(d))
print('len:', len(d))

# 删除
del d
print(d)
'''
'''
# 字典的访问和遍历
d = {'cat': 10, 'dog': 20, 'tom': 30}
# (1) 使用d[key]
print(d['cat'])

# (2) 使用get(key)
print(d.get('banana'))  # None
print(d.get('banana', '不存在'))  # 指定默认值为 '不存在'
# 二者的区别: 如果key不存在,d[key]会报错 ,d.get()可以指定默认值

# 字典的遍历
for item in d.items():
    print(item)  # key=value 组成的一个元素

# 在使用for循环遍历是,可分别取key,value
for key, value in d.items():
    print(key, '--->', value)
'''
'''
## 字典的相关操作方法
d = {'cat': 10, 'dog': 20, 'tom': 30}
print(d)

# 添加元素
d['banana'] = 40
print(d)

# 获取字典中所有的key
keys = d.keys()
print(keys)
print(list(keys))  # 将获取到的所有键转化为列表
print(tuple(keys))  # 将获取到的所有键转化为元组

# 获取字典中所有的value
values = d.values()
print(values)
print(list(values))  # 将获取到的所有值转化为列表
print(tuple(values))  # 将获取到的所有值转化为元组

# 如果将字典中的数据转成key-value的形式,以元组的方式展现
lst = list(d.items())
print(lst)

# 将元组转化为key-value的形式
lst = dict(lst)
print(lst)

# 使用pop()函数
print(d.pop('cat'))
print(d)

print(d.pop('taige', '不存在'))  # 删除一个值 不存在时返回默认值

# 随机删除
print(d.popitem())
print(d)

# 清空所有的元素
d.clear()
print(d)

# Python中一切皆对象,每个对象都有一个布尔值
print(bool(d))  # 空字典的bool值为False

# 字典的生成式
d = {item: random.randint(0, 100) for item in range(4)}
print(d)

# 创建两个列表
lst1 = [100, 102, 205]
lst2 = ['张三', '李四', '王五']
d = {key: value for key, value in zip(lst1, lst2)}
print(d)

# 迭代器
lst = {'tom': 100, 'bob': 200, 'jerry': 300}
print(list(iter(lst)))


# 集合的创建与删除
s = {10, 20, 30}
print(s)

# 集合只能存储不可变数据类型
# s = {[10, 20], [30, 40]}  # TypeError: unhashable type: 'list'
# print(s)
# 使用set()创建集合
s = set()  # 创建空集合 布尔值:Falsse
print(s)

s = {}  # 创建的是字典
print(type(s))  # dict

s = set('hello')  # 集合无序且不重复
print(s)

s2 = set(['hello', 'world'])
print(s2)

s3 = set(range(1, 10))
print(s3)

# 集合数据序列的一种
print('最大值:', max(s3))
print('最小值:', min(s3))
print('len:', len(s3))
print('9在集合中存在么:', 9 in s3)
print('9不存在与集合中么', 9 not in s3)

# 集合的删除操作
del s3
print(s3)


# 集合的操作符
a = {10, 20, 30, 40, 50}
b = {40, 50, 60, 70, 80}

# 交集
print(a & b)

# 并集 把两个集合合并到一起并去除重复元素
print(a | b)

# 差集 a中存在b中不存在的元素
print(a - b)

# 补集  a和b中不相交的部分
print(a ^ b)


s = {10, 20, 30, 40, 50}
# 向集合中添加元素
s.add(60)
print(s)

# 删除元素
s.remove(30)
print(s)

# 清空集合中所有元素
s.clear()
print(s)

# 集合的遍历
s = {10, 20, 30, 40, 50}
for item in s:
    print(item)

# 使用enumerate()函数遍历
for index, item in enumerate(s, start=1):
    print(index, '--->', item)

# 集合生成式
s = {item for item in range(10)}
print(s)

s = {item for item in range(10) if item % 2 == 0}
print(s)
'''
